home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / omega / olev.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-08-06  |  15.6 KB  |  477 lines
  1. /* omega copyright (c) 1987,1988 by Laurence Raphael Brothers */
  2. /* olev.c */
  3.  
  4. #include "oglob.h"
  5.  
  6. /* Functions dealing with dungeon and country levels aside from actual
  7. level structure generation */
  8.  
  9.  
  10. /* monsters for tactical encounters */
  11. void make_country_monsters(terrain)
  12. char terrain;
  13. {
  14.   pml tml,ml=NULL;
  15.   static int plains[10] = 
  16.     {BUNNY,BUNNY,BLACKSNAKE,HAWK,IMPALA,WOLF,LION,BRIGAND,RANDOM};
  17.   static int forest[10] =
  18.    {BUNNY,QUAIL,HAWK,BADGER,DEER,DEER,WOLF,BEAR,BRIGAND,RANDOM};
  19.   static int jungle[10] =
  20.     {ANTEATER,PARROT,MAMBA,ANT,ANT,HYENA,HYENA,ELEPHANT,LION,RANDOM};
  21.   static int river[10] =
  22.     {QUAIL,TROUT,TROUT,MANOWAR,BASS,BASS,CROC,CROC,BRIGAND,RANDOM};
  23.   static int swamp[10] =
  24.     {BASS,BASS,CROC,CROC,BOGTHING,ANT,ANT,RANDOM,RANDOM,RANDOM};
  25.   static int desert[10] =
  26.     {HAWK,HAWK,CAMEL,CAMEL,HYENA,HYENA,LION,LION,RANDOM,RANDOM};
  27.   static int tundra[10] =
  28.     {WOLF,WOLF,BEAR,BEAR,DEER,DEER,RANDOM,RANDOM,RANDOM,RANDOM};
  29.   static int mountain[10] =
  30.     {BUNNY,SHEEP,WOLF,WOLF,HAWK,HAWK,HAWK,RANDOM,RANDOM,RANDOM};
  31.   int *monsters,i,nummonsters;
  32.  
  33.   nummonsters = (random_range(5)+1) * (random_range(3)+1);
  34.  
  35.   switch(terrain) {
  36.   case PLAINS: monsters = plains; break;
  37.   case FOREST: monsters = forest; break;
  38.   case JUNGLE: monsters = jungle; break;
  39.   case RIVER: monsters = river; break;
  40.   case SWAMP: monsters = swamp; break;
  41.   case MOUNTAINS: case PASS: case VOLCANO: monsters = mountain; break;
  42.   case DESERT: monsters = desert; break;
  43.   case TUNDRA: monsters = tundra; break;
  44.   default: monsters = NULL;
  45.   }
  46.   for(i=0;i<nummonsters;i++) {
  47.     tml = ((pml) malloc(sizeof(mltype)));
  48.     tml->m = ((pmt) malloc(sizeof(montype)));
  49.     if (monsters == NULL) tml->m = 
  50.       m_create(random_range(WIDTH),random_range(LENGTH),TRUE,difficulty());
  51.     else {
  52.       tml->m = make_creature(*(monsters+random_range(10)));
  53.       tml->m->x = random_range(WIDTH);
  54.       tml->m->y = random_range(LENGTH);
  55.     }
  56.     Level->site[tml->m->x][tml->m->y].creature = tml->m;
  57.     tml->m->sense = WIDTH;
  58.     if (m_statusp(tml->m,ONLYSWIM)) {
  59.       Level->site[tml->m->x][tml->m->y].locchar = WATER;
  60.       Level->site[tml->m->x][tml->m->y].p_locf = L_WATER;
  61.     }
  62.  
  63.     tml->next = ml;
  64.     ml = tml;
  65.   }
  66.   Level->mlist = ml;
  67. }
  68.  
  69.  
  70.  
  71. /* monstertype is more or less Current_Dungeon */
  72. /* The caves and sewers get harder as you penetrate them; the castle
  73. is completely random, but also gets harder as it is explored;
  74. the astral and the volcano just stay hard... */
  75. void populate_level(monstertype)
  76. int monstertype;
  77. {
  78.   pml head,tml;
  79.   int i,j,k,monsterid,nummonsters=(random_range(difficulty()/3)+1)*3+8;
  80.  
  81.   if (monstertype == E_CASTLE) nummonsters += 10;
  82.   else if (monstertype == E_ASTRAL) nummonsters += 10;
  83.   else if (monstertype == E_VOLCANO) nummonsters += 20;
  84.  
  85.   head = tml = ((pml) malloc(sizeof(mltype)));
  86.  
  87.   for(k=0;k<nummonsters;k++) {
  88.  
  89.     findspace(&i,&j,-1);
  90.  
  91.     switch(monstertype) {
  92.     case E_CAVES:
  93.       if (Level->depth*10+random_range(100) > 150) 
  94.     monsterid = ML3+7; /* Goblin Shaman*/
  95.       else if (Level->depth*10+random_range(100) > 100) 
  96.     monsterid = ML2+9; /* Goblin Chieftain */
  97.       else if (random_range(100) > 50) monsterid = ML1+6; /* Goblin */
  98.       else monsterid = -1; /* IE, random monster */
  99.       break;
  100.     case E_SEWERS:
  101.       if (! random_range(3)) monsterid = -1;
  102.       else switch(random_range(Level->depth+3)) {
  103.       case 0: monsterid = ML1+3; break; /* sewer rat */
  104.       case 1: monsterid = ML1+4; break; /* aggravator fungus */
  105.       case 2: monsterid = ML1+5; break; /* blipper rat */
  106.       case 3: monsterid = ML2+1; break; /* night gaunt */
  107.       case 4: monsterid = ML2+5; break; /* transparent nasty */
  108.       case 5: monsterid = ML2+8; break; /* murk fungus */
  109.       case 6: monsterid = ML3+1; break; /* catoblepas */
  110.       case 7: monsterid = ML3+3; break; /* acid cloud */
  111.       case 8: monsterid = ML4+3; break; /* denebian slime devil */
  112.       case 9: monsterid = ML4+8; break; /* giant crocodile */
  113.       case 10: monsterid = ML5+1; break; /* tesla monster */
  114.       case 11: monsterid = ML5+7; break; /* shadow spirit */
  115.       case 12: monsterid = ML5+8; break; /* bogthing */
  116.       case 13: monsterid = ML6+2; break; /* water elemental */
  117.       case 14: monsterid = ML6+6; break; /* triton */
  118.       case 15: monsterid = ML7+3; break; /* ROUS */
  119.       default: monsterid = -1; break;
  120.       }
  121.       break;
  122.     case E_ASTRAL:
  123.       if (random_range(2)) /* random astral creatures */
  124.     switch(random_range(12)) {
  125.     case 0: monsterid = ML3+14; break; /* thought form */
  126.     case 1: monsterid = ML4+11; break; /* astral fuzzy */
  127.     case 2: monsterid = ML4+15; break; /* ban sidhe */
  128.     case 3: monsterid = ML4+16; break; /* astral grue */
  129.     case 4: monsterid = ML5+7; break; /* shadow spirit */
  130.     case 5: monsterid = ML5+9; break; /* astral vampire */
  131.     case 6: monsterid = ML5+11; break; /* manaburst */
  132.     case 7: monsterid = ML6+9; break; /* rakshasa */
  133.     case 8: monsterid = ML7+4; break; /* illusory fiend */
  134.     case 9: monsterid = ML7+9; break; /* mirror master */
  135.     case 10: monsterid = ML7+10; break; /* elder etheric grue */
  136.     case 11: monsterid = ML8+8; break; /* shadow slayer */
  137.     }
  138.       else if (random_range(2) && (Level->depth == 1)) /* plane of earth */
  139.     monsterid = ML6+3; /* earth elemental */
  140.       else if (random_range(2) && (Level->depth == 2)) /* plane of air */
  141.     monsterid = ML6+1;  /* air elemental */
  142.       else if (random_range(2) && (Level->depth == 3)) /* plane of water */
  143.     monsterid = ML6+2;  /* water elemental */
  144.       else if (random_range(2) && (Level->depth == 4)) /* plane of fire */
  145.     monsterid = ML6+0;  /* fire elemental */
  146.       else if (random_range(2) && (Level->depth == 5)) /* deep astral */
  147.     switch (random_range(12)) {
  148.     case 0:monsterid = ML2+1; break; /* night gaunt */
  149.     case 1:monsterid = ML4+12; break; /* servant of law */
  150.     case 2:monsterid = ML4+13; break; /* servant of chaos */
  151.     case 3:monsterid = ML5+4; break; /* lesser frost demon */
  152.     case 4:monsterid = ML5+12; break; /* outer circle demon */
  153.     case 5:monsterid = ML6+10; break; /* demon serpent */
  154.     case 6:monsterid = ML6+11; break; /* angel */
  155.     case 7:monsterid = ML7+14; break; /* inner circle demon */
  156.     case 8:monsterid = ML8+5; break; /* frost demon lord */
  157.     case 9:monsterid = ML8+11; break; /* high angel */
  158.     case 10:monsterid = ML9+7; break; /* prime circle demon */
  159.     case 11:monsterid = ML9+6; break; /* archangel */
  160.     }
  161.       else monsterid = -1;
  162.       break;
  163.     case E_VOLCANO:
  164.       if (random_range(2)) {
  165.     do monsterid = random_range(ML10-ML4)+ML4;
  166.     while (Monsters[monsterid].uniqueness != COMMON);
  167.       }
  168.       else switch(random_range(Level->depth/2+2)) { /* evil & fire creatures */
  169.       case 0: monsterid = ML4+5; break;
  170.       case 1: monsterid = ML4+6; break;
  171.       case 2: monsterid = ML5+0; break;
  172.       case 3: monsterid = ML5+4; break;
  173.       case 4: monsterid = ML5+5; break;
  174.       case 5: monsterid = ML5+10; break;
  175.       case 6: monsterid = ML6+0; break;
  176.       case 7: monsterid = ML6+5; break;
  177.       case 8: monsterid = ML6+9; break;
  178.       case 9: monsterid = ML6+10; break;
  179.       case 10: monsterid = ML7+1; break;
  180.       case 11: monsterid = ML7+6; break;
  181.       case 12: monsterid = ML7+11; break;
  182.       case 13: monsterid = ML7+12; break;
  183.       case 14: monsterid = ML7+14; break;
  184.       case 15: monsterid = ML7+3; break; 
  185.       case 16: monsterid = ML8+3; break; 
  186.       case 17: monsterid = ML8+5; break; 
  187.       case 18: monsterid = ML8+8; break; 
  188.       case 19: monsterid = ML7+3; break; 
  189.       case 20: monsterid = ML9+5; break; 
  190.       case 21: monsterid = ML9+7; break; 
  191.       default: monsterid = -1; break;
  192.       }
  193.       break;      
  194.     case E_CASTLE: 
  195.       if (random_range(4)==1) {
  196.     if (difficulty() < 5)
  197.       monsterid = ML2+7;
  198.     else if (difficulty() < 6)
  199.       monsterid = ML5+6;
  200.     else if (difficulty() < 8)
  201.       monsterid = ML6+0;
  202.     else monsterid = ML9+4;
  203.       }
  204.       else monsterid = -1;
  205.     break;
  206.  
  207.     default: monsterid = -1; break;
  208.     }
  209.     
  210.     if (monsterid > -1)
  211.       Level->site[i][j].creature = make_creature(monsterid);
  212.     else Level->site[i][j].creature = m_create(i,j,TRUE,difficulty());
  213.  
  214.  
  215.     Level->site[i][j].creature->x = i;
  216.     Level->site[i][j].creature->y = j;
  217.     
  218.     if (m_statusp(Level->site[i][j].creature,ONLYSWIM)) {
  219.       Level->site[i][j].locchar = WATER;
  220.       Level->site[i][j].p_locf = L_WATER;
  221.     }
  222.     
  223.     tml->next = ((pml) malloc(sizeof(mltype)));
  224.     tml->next->m = Level->site[i][j].creature;
  225.     tml = tml->next;
  226.   }
  227.   
  228.   if (Level->mlist==NULL) {
  229.     tml->next = NULL;
  230.     Level->mlist = head->next;
  231.   }
  232.   else {
  233.     tml->next = Level->mlist;
  234.     Level->mlist = head->next;
  235.   }
  236. }
  237.  
  238.  
  239.  
  240. /* Add a wandering monster possibly */
  241. void wandercheck()
  242. {
  243.   int x,y;
  244.   pml tml;
  245.   if (random_range(MaxDungeonLevels) < difficulty()) {
  246.     findspace(&x,&y,-1);
  247.     tml = ((pml) malloc(sizeof(mltype)));
  248.     tml->next = Level->mlist;
  249.     tml->m = Level->site[x][y].creature = m_create(x,y,WANDERING,difficulty());
  250.     Level->mlist = tml;    
  251.   }
  252. }
  253.  
  254.  
  255.  
  256. /* call make_creature and place created monster on Level->mlist and Level */
  257. void make_site_monster(i,j,mid)
  258. int i,j,mid;
  259. {
  260.   pml ml = ((pml) malloc(sizeof(mltype)));
  261.   pmt m;
  262.   if (mid > -1)  Level->site[i][j].creature = (m = make_creature(mid));
  263.   else Level->site[i][j].creature = (m = m_create(i,j,WANDERING,difficulty()));
  264.   m->x = i;
  265.   m->y = j;
  266.   ml->m = m;
  267.   ml->next = Level->mlist;
  268.   Level->mlist = ml;
  269. }
  270.  
  271.  
  272. /* make and return an appropriate monster for the level and depth*/
  273. /* called by populate_level, doesn't actually add to mlist for some reason*/
  274. /* eventually to be more intelligent */
  275. pmt m_create(x,y,kind,level)
  276. int x,y,kind,level;
  277. {
  278.   pmt newmonster;
  279.   int monster_range;
  280.   int mid;
  281.  
  282.   switch(level) {
  283.     case 0:monster_range = ML1; break;
  284.     case 1:monster_range = ML2; break;
  285.     case 2:monster_range = ML3; break;
  286.     case 3:monster_range = ML4; break;
  287.     case 4:monster_range = ML5; break;
  288.     case 5:monster_range = ML6; break;
  289.     case 6:monster_range = ML7; break;
  290.     case 7:monster_range = ML8; break;
  291.     case 8:monster_range = ML9; break;
  292.     case 9:monster_range = ML10; break;
  293.     default:monster_range = NUMMONSTERS; break;
  294.   }
  295.  
  296.   do 
  297.     mid = random_range(monster_range);
  298.   while (Monsters[mid].uniqueness != COMMON); 
  299.   newmonster = make_creature(mid);
  300.  
  301.   /* no duplicates of unique monsters */
  302.   if (kind == WANDERING) m_status_set(newmonster,WANDERING);
  303.   newmonster->x = x;
  304.   newmonster->y = y;
  305.   return(newmonster);
  306. }
  307.  
  308.  
  309.  
  310. /* make creature # mid, totally random if mid == -1 */
  311. /* make creature allocates space for the creature */
  312. pmt make_creature(mid)
  313. int mid;
  314. {
  315.   pmt newmonster = ((pmt) malloc(sizeof(montype)));
  316.   pob ob;
  317.   int i,treasures;
  318.  
  319.   if (mid == -1) mid = random_range(ML9);
  320.   *newmonster = Monsters[mid];
  321.   if ((mid == ML6+11) || (mid == ML8+11) || (mid == ML9+6)) {
  322.     /* aux1 field of an angel is its deity */
  323.     newmonster->aux1 = random_range(6)+1;
  324.     newmonster->corpsestr = salloc(Monsters[mid].corpsestr);
  325.     strcpy(Str3,Monsters[mid].monstring);
  326.     switch(newmonster->aux1) {
  327.     case ODIN: strcat(Str3," of Odin"); break;
  328.     case SET: strcat(Str3," of Set"); break;
  329.     case HECATE: strcat(Str3," of Hecate"); break;
  330.     case ATHENA: strcat(Str3," of Athena"); break;
  331.     case DESTINY: strcat(Str3," of Destiny"); break;
  332.     case DRUID: strcat(Str3," of the Balance"); break;
  333.     }
  334.     newmonster->monstring = salloc(Str3);
  335.   }
  336.   else if (mid == ML0+7) { 
  337.     /* generic 0th level human */
  338.     newmonster->monstring = salloc(mantype());
  339.     strcpy(Str1,"dead ");
  340.     strcat(Str1,newmonster->monstring);
  341.     newmonster->corpsestr = salloc(Str1);
  342.   }
  343.   else if (newmonster->monchar == '!') {
  344.     /* the nymph/satyr and incubus/succubus */
  345.     if (Player.preference == 'f') {
  346.       newmonster->monchar = 'n';
  347.       newmonster->monstring = salloc("nymph");
  348.       newmonster->corpsestr = salloc("dead nymph");
  349.     }
  350.     else {
  351.       newmonster->monchar = 's';
  352.       newmonster->monstring = salloc("satyr");
  353.       newmonster->corpsestr = salloc("dead satyr");
  354.     }
  355.     if (newmonster->id == ML4+6) {
  356.       if (Player.preference == 'f') 
  357.     newmonster->corpsestr = salloc("dead succubus");
  358.       else newmonster->corpsestr = salloc("dead incubus");
  359.     }
  360.   }
  361.   if (mid == NPC)
  362.     make_log_npc(newmonster);
  363.   else {
  364.     if (newmonster->sleep < random_range(100))
  365.       m_status_set(newmonster,AWAKE);
  366.     if (newmonster->startthing > -1) {
  367.       ob = ((pob) malloc(sizeof(objtype)));    
  368.       *ob = Objects[newmonster->startthing];
  369.       m_pickup(newmonster,ob);
  370.     }
  371.     treasures = random_range(newmonster->treasure);
  372.     for(i=0;i<treasures;i++) {
  373.       ob = ((pob) malloc(sizeof(objtype)));    
  374.       do ob = ((pob) (create_object(newmonster->level)));
  375.       while (ob->uniqueness != 0);
  376.       m_pickup(newmonster,ob);
  377.     }
  378.   }
  379.   newmonster->click = (Tick + 1) % 50;
  380.   return(newmonster);
  381. }
  382.  
  383.  
  384.  
  385.  
  386. /* drop treasures randomly onto level */
  387. void stock_level()
  388. {
  389.   int i,j,k,numtreasures=2*random_range(difficulty()/4)+4;
  390.  
  391.   /* put cash anywhere, including walls, put other treasures only on floor */
  392.   for (k=0;k<numtreasures+10;k++) {
  393.     do {
  394.       i = random_range(WIDTH);
  395.       j = random_range(LENGTH);
  396.     } while (Level->site[i][j].locchar != FLOOR);
  397.     make_site_treasure(i,j,difficulty());
  398.     i = random_range(WIDTH);
  399.     j = random_range(LENGTH);
  400.     Level->site[i][j].things = ((pol) malloc(sizeof(oltype)));
  401.     Level->site[i][j].things->thing = ((pob) malloc(sizeof(objtype)));
  402.     make_cash(Level->site[i][j].things->thing,difficulty());
  403.     Level->site[i][j].things->next = NULL;
  404.     /* caves have more random cash strewn around */
  405.     if (Current_Dungeon == E_CAVES) {
  406.       i = random_range(WIDTH);
  407.       j = random_range(LENGTH);
  408.       Level->site[i][j].things = ((pol) malloc(sizeof(oltype)));
  409.       Level->site[i][j].things->thing = ((pob) malloc(sizeof(objtype)));
  410.       make_cash(Level->site[i][j].things->thing,difficulty());
  411.       Level->site[i][j].things->next = NULL;
  412.       i = random_range(WIDTH);
  413.       j = random_range(LENGTH);
  414.       Level->site[i][j].things = ((pol) malloc(sizeof(oltype)));
  415.       Level->site[i][j].things->thing = ((pob) malloc(sizeof(objtype)));
  416.       make_cash(Level->site[i][j].things->thing,difficulty());
  417.       Level->site[i][j].things->next = NULL;
  418.     }
  419.   }
  420. }
  421.  
  422.  
  423. /* make a new object (of at most level itemlevel) at site i,j on level*/
  424. void make_site_treasure(i,j,itemlevel)
  425. int i,j,itemlevel;
  426. {
  427.   pol tmp = ((pol) malloc(sizeof(oltype)));
  428.   tmp->thing = ((pob) create_object(itemlevel));
  429.   tmp->next = Level->site[i][j].things;
  430.   Level->site[i][j].things = tmp;
  431. }
  432.  
  433. /* make a specific new object at site i,j on level*/
  434. void make_specific_treasure(i,j,itemid)
  435. int i,j,itemid;
  436. {
  437.   pol tmp = ((pol) malloc(sizeof(oltype)));
  438.   tmp->thing = ((pob) malloc(sizeof(objtype)));
  439.   *(tmp->thing) = Objects[itemid];
  440.   tmp->next = Level->site[i][j].things;
  441.   Level->site[i][j].things = tmp;
  442. }
  443.  
  444.  
  445.  
  446. /* returns a "level of difficulty" based on current environment
  447.    and depth in dungeon. Is somewhat arbitrary. value between 1 and 10.
  448.    May not actually represent real difficulty, but instead level
  449.    of items, monsters encountered.    */
  450. int difficulty()
  451. {
  452.   int depth = 1;
  453.   if (Level != NULL) depth = Level->depth;
  454.   switch(Current_Environment) {
  455.   case E_COUNTRYSIDE: return(7); break;
  456.   case E_CITY: return(3); break;
  457.   case E_VILLAGE: return(1); break;
  458.   case E_TACTICAL_MAP: return(7); break;
  459.   case E_SEWERS: return(depth/6)+3;break;
  460.   case E_CASTLE: return(depth/4)+4;break;
  461.   case E_CAVES: return(depth/3)+1;break;
  462.   case E_VOLCANO: return(depth/4)+5;break;
  463.   case E_ASTRAL: return(8);break;
  464.   case E_ARENA: return(5);break;
  465.   case E_HOVEL: return(3);break;
  466.   case E_MANSION: return(7);break;
  467.   case E_HOUSE: return(5);break;
  468.   case E_DLAIR: return(9);break;
  469.   case E_ABYSS: return(10);break;
  470.   case E_STARPEAK: return(9);break;
  471.   case E_CIRCLE: return(8);break;
  472.   case E_MAGIC_ISLE: return(8);break;
  473.   case E_TEMPLE: return(8);break;
  474.   default: return(3); break;
  475.   }
  476. }
  477.